home *** CD-ROM | disk | FTP | other *** search
/ Ham Radio 2000 #1 / Ham Radio 2000.iso / ham2000 / misc / dspice0s / sorupd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-11-22  |  14.6 KB  |  513 lines
  1. /* sorupd.f -- translated by f2c (version of 3 February 1990  3:36:42).
  2.    You must link the resulting object file with the libraries:
  3.     -lF77 -lI77 -lm -lc   (in that order)
  4. */
  5.  
  6. #include "f2c.h"
  7.  
  8. /* Common Block Declarations */
  9.  
  10. struct {
  11.     integer ielmnt, isbckt, nsbckt, iunsat, nunsat, itemps, numtem, isens, 
  12.         nsens, ifour, nfour, ifield, icode, idelim, icolum, insize, 
  13.         junode, lsbkpt, numbkp, iorder, jmnode, iur, iuc, ilc, ilr, 
  14.         numoff, isr, nmoffc, iseq, iseq1, neqn, nodevs, ndiag, iswap, 
  15.         iequa, macins, lvnim1, lx0, lvn, lynl, lyu, lyl, lx1, lx2, lx3, 
  16.         lx4, lx5, lx6, lx7, ld0, ld1, ltd, imynl, imvn, lcvn, nsnod, 
  17.         nsmat, nsval, icnod, icmat, icval, loutpt, lpol, lzer, irswpf, 
  18.         irswpr, icswpf, icswpr, irpt, jcpt, irowno, jcolno, nttbr, nttar, 
  19.         lvntmp;
  20. } tabinf_;
  21.  
  22. #define tabinf_1 tabinf_
  23.  
  24. struct {
  25.     integer locate[50], jelcnt[50], nunods, ncnods, numnod, nstop, nut, nlt, 
  26.         nxtrm, ndist, ntlin, ibr, numvs, numalt, numcyc;
  27. } cirdat_;
  28.  
  29. #define cirdat_1 cirdat_
  30.  
  31. struct {
  32.     doublereal omega, time, delta, delold[7], ag[7], vt, xni, egfet, xmu, 
  33.         sfactr;
  34.     integer mode, modedc, icalc, initf, method, iord, maxord, noncon, iterno, 
  35.         itemno, nosolv, modac, ipiv, ivmflg, ipostp, iscrch, iofile;
  36. } status_;
  37.  
  38. #define status_1 status_
  39.  
  40. struct {
  41.     integer iprnta, iprntl, iprntm, iprntn, iprnto, limtim, limpts, lvlcod, 
  42.         lvltim, itl1, itl2, itl3, itl4, itl5, itl6, igoof, nogo, keof;
  43. } flags_;
  44.  
  45. #define flags_1 flags_
  46.  
  47. struct {
  48.     doublereal value[200000];
  49. } blank_;
  50.  
  51. #define blank_1 blank_
  52.  
  53. /* Table of constant values */
  54.  
  55. static integer c__1 = 1;
  56.  
  57. /*<       subroutine sorupd >*/
  58. /* Subroutine */ int sorupd_()
  59. {
  60.     /* Format strings */
  61.     static char fmt_901[] = "(\0020*abort*:  internal spice error:  sorupd: \
  62.  \002,2i5/)";
  63.  
  64.     /* Builtin functions */
  65.     double sin(), exp();
  66.     integer s_wsfe(), do_fio(), e_wsfe();
  67.  
  68.     /* Local variables */
  69.     static doublereal omeg;
  70.     static integer locp, locv, iknt;
  71.     static doublereal xmod, dt1t2, dt1t3, dt2t3, time1, omegc, theta, omegs;
  72.     static integer icntr, itype, numtd, l1, l2, l3;
  73.     static doublereal t1, t2, v1, v2, t3, t4, tfact1, tfact2, tfact3, tdnom1, 
  74.         tdnom2, tdnom3;
  75.     static integer id;
  76.     static doublereal td, baktim;
  77. #define nodplc ((integer *)&blank_1)
  78. #define cvalue ((complex *)&blank_1)
  79.     static doublereal period;
  80.     extern /* Subroutine */ int sizmem_();
  81.     static integer ltdsiz, ltdptr, loc;
  82.     static doublereal tau1, tau2, dtt1, dtt2, dtt3;
  83.  
  84.     /* Fortran I/O blocks */
  85.     static cilist io__45 = { 0, 0, 0, fmt_901, 0 };
  86.  
  87.  
  88. /*<       implicit double precision (a-h,o-z) >*/
  89.  
  90. /*     this routine updates the independent voltage and current sources */
  91.  
  92. /* used in the circuit.  it also updates the ltd table (which contains */
  93. /* previous (delayed) values of the sources used to model transmission */
  94. /* lines). */
  95.  
  96. /* spice version 2g.6  sccsid=tabinf 3/15/83 */
  97. /*<       common /tabinf/ ielmnt,isbckt,nsbckt,iunsat,nunsat,itemps,numtem, >*/
  98. /*<      1   isens,nsens,ifour,nfour,ifield,icode,idelim,icolum,insize, >*/
  99. /*<      2   junode,lsbkpt,numbkp,iorder,jmnode,iur,iuc,ilc,ilr,numoff,isr, >*/
  100. /*<      3   nmoffc,iseq,iseq1,neqn,nodevs,ndiag,iswap,iequa,macins,lvnim1, >*/
  101. /*<      4   lx0,lvn,lynl,lyu,lyl,lx1,lx2,lx3,lx4,lx5,lx6,lx7,ld0,ld1,ltd, >*/
  102. /*<      5   imynl,imvn,lcvn,nsnod,nsmat,nsval,icnod,icmat,icval, >*/
  103. /*<      6   loutpt,lpol,lzer,irswpf,irswpr,icswpf,icswpr,irpt,jcpt, >*/
  104. /*<      7   irowno,jcolno,nttbr,nttar,lvntmp >*/
  105. /* spice version 2g.6  sccsid=cirdat 3/15/83 */
  106. /*<       common /cirdat/ locate(50),jelcnt(50),nunods,ncnods,numnod,nstop, >*/
  107. /*<      1   nut,nlt,nxtrm,ndist,ntlin,ibr,numvs,numalt,numcyc >*/
  108. /* spice version 2g.6  sccsid=status 3/15/83 */
  109. /*<       common /status/ omega,time,delta,delold(7),ag(7),vt,xni,egfet, >*/
  110. /*<      1   xmu,sfactr,mode,modedc,icalc,initf,method,iord,maxord,noncon, >*/
  111. /*<      2   iterno,itemno,nosolv,modac,ipiv,ivmflg,ipostp,iscrch,iofile >*/
  112. /* spice version 2g.6  sccsid=flags 3/15/83 */
  113. /*<       common /flags/ iprnta,iprntl,iprntm,iprntn,iprnto,limtim,limpts, >*/
  114. /*<      1   lvlcod,lvltim,itl1,itl2,itl3,itl4,itl5,itl6,igoof,nogo,keof >*/
  115. /* spice version 2g.6  sccsid=blank 3/15/83 */
  116. /*<       common /blank/ value(200000) >*/
  117. /*<       integer nodplc(64) >*/
  118. /*<       complex cvalue(32) >*/
  119. /*<       equivalence (value(1),nodplc(1),cvalue(1)) >*/
  120.  
  121.  
  122. /*<       do 500 id=9,10 >*/
  123.     for (id = 9; id <= 10; ++id) {
  124. /*<       loc=locate(id) >*/
  125.     loc = cirdat_1.locate[id - 1];
  126. /*<    10 if (loc.eq.0) go to 500 >*/
  127. L10:
  128.     if (loc == 0) {
  129.         goto L500;
  130.     }
  131. /*<       if ((id.eq.9).and.(nodplc(loc+11).ne.0)) go to 500 >*/
  132.     if (id == 9 && nodplc[loc + 10] != 0) {
  133.         goto L500;
  134.     }
  135. /*<       if ((id.eq.10).and.(nodplc(loc+6).ne.0)) go to 500 >*/
  136.     if (id == 10 && nodplc[loc + 5] != 0) {
  137.         goto L500;
  138.     }
  139. /*<       locv=nodplc(loc+1) >*/
  140.     locv = nodplc[loc];
  141. /*<       locp=nodplc(loc+5) >*/
  142.     locp = nodplc[loc + 4];
  143. /*<       itype=nodplc(loc+4)+1 >*/
  144.     itype = nodplc[loc + 3] + 1;
  145. /*<       go to (490,100,200,300,400,450), itype >*/
  146.     switch (itype) {
  147.         case 1:  goto L490;
  148.         case 2:  goto L100;
  149.         case 3:  goto L200;
  150.         case 4:  goto L300;
  151.         case 5:  goto L400;
  152.         case 6:  goto L450;
  153.     }
  154.  
  155. /*  pulse source */
  156.  
  157. /*<   100 v1=value(locp+1) >*/
  158. L100:
  159.     v1 = blank_1.value[locp];
  160. /*<       v2=value(locp+2) >*/
  161.     v2 = blank_1.value[locp + 1];
  162. /*<       t1=value(locp+3) >*/
  163.     t1 = blank_1.value[locp + 2];
  164. /*<       t2=value(locp+4) >*/
  165.     t2 = blank_1.value[locp + 3];
  166. /*<       t3=value(locp+5) >*/
  167.     t3 = blank_1.value[locp + 4];
  168. /*<       t4=value(locp+6) >*/
  169.     t4 = blank_1.value[locp + 5];
  170. /*<       period=value(locp+7) >*/
  171.     period = blank_1.value[locp + 6];
  172. /*<       time1=time >*/
  173.     time1 = status_1.time;
  174. /*<       if (time1.le.0.0d0) go to 160 >*/
  175.     if (time1 <= 0.) {
  176.         goto L160;
  177.     }
  178. /*<   110 if (time1.lt.t1+period) go to 120 >*/
  179. L110:
  180.     if (time1 < t1 + period) {
  181.         goto L120;
  182.     }
  183. /*<       time1=time1-period >*/
  184.     time1 -= period;
  185. /*<       go to 110 >*/
  186.     goto L110;
  187. /*<   120 if (time1.lt.t4) go to 130 >*/
  188. L120:
  189.     if (time1 < t4) {
  190.         goto L130;
  191.     }
  192. /*<       value(locv+1)=v1 >*/
  193.     blank_1.value[locv] = v1;
  194. /*<       go to 490 >*/
  195.     goto L490;
  196. /*<   130 if (time1.lt.t3) go to 140 >*/
  197. L130:
  198.     if (time1 < t3) {
  199.         goto L140;
  200.     }
  201. /*<       value(locv+1)=v2+(time1-t3)*(v1-v2)/(t4-t3) >*/
  202.     blank_1.value[locv] = v2 + (time1 - t3) * (v1 - v2) / (t4 - t3);
  203. /*<       go to 490 >*/
  204.     goto L490;
  205. /*<   140 if (time1.lt.t2) go to 150 >*/
  206. L140:
  207.     if (time1 < t2) {
  208.         goto L150;
  209.     }
  210. /*<       value(locv+1)=v2 >*/
  211.     blank_1.value[locv] = v2;
  212. /*<       go to 490 >*/
  213.     goto L490;
  214. /*<   150 if (time1.lt.t1) go to 160 >*/
  215. L150:
  216.     if (time1 < t1) {
  217.         goto L160;
  218.     }
  219. /*<       value(locv+1)=v1+(time1-t1)*(v2-v1)/(t2-t1) >*/
  220.     blank_1.value[locv] = v1 + (time1 - t1) * (v2 - v1) / (t2 - t1);
  221. /*<       go to 490 >*/
  222.     goto L490;
  223. /*<   160 value(locv+1)=v1 >*/
  224. L160:
  225.     blank_1.value[locv] = v1;
  226. /*<       go to 490 >*/
  227.     goto L490;
  228.  
  229. /*  sinusoidal source */
  230.  
  231. /*<   200 v1=value(locp+1) >*/
  232. L200:
  233.     v1 = blank_1.value[locp];
  234. /*<       v2=value(locp+2) >*/
  235.     v2 = blank_1.value[locp + 1];
  236. /*<       omeg=value(locp+3) >*/
  237.     omeg = blank_1.value[locp + 2];
  238. /*<       t1=value(locp+4) >*/
  239.     t1 = blank_1.value[locp + 3];
  240. /*<       theta=value(locp+5) >*/
  241.     theta = blank_1.value[locp + 4];
  242. /*<       time1=time-t1 >*/
  243.     time1 = status_1.time - t1;
  244. /*<       if (time1.gt.0.0d0) go to 210 >*/
  245.     if (time1 > 0.) {
  246.         goto L210;
  247.     }
  248. /*<       value(locv+1)=v1 >*/
  249.     blank_1.value[locv] = v1;
  250. /*<       go to 490 >*/
  251.     goto L490;
  252. /*<   210 if (theta.ne.0.0d0) go to 220 >*/
  253. L210:
  254.     if (theta != 0.) {
  255.         goto L220;
  256.     }
  257. /*<       value(locv+1)=v1+v2*dsin(omeg*time1) >*/
  258.     blank_1.value[locv] = v1 + v2 * sin(omeg * time1);
  259. /*<       go to 490 >*/
  260.     goto L490;
  261. /*<   220 value(locv+1)=v1+v2*dsin(omeg*time1)*dexp(-time1*theta) >*/
  262. L220:
  263.     blank_1.value[locv] = v1 + v2 * sin(omeg * time1) * exp(-time1 * 
  264.         theta);
  265. /*<       go to 490 >*/
  266.     goto L490;
  267.  
  268. /*  exponential source */
  269.  
  270. /*<   300 v1=value(locp+1) >*/
  271. L300:
  272.     v1 = blank_1.value[locp];
  273. /*<       v2=value(locp+2) >*/
  274.     v2 = blank_1.value[locp + 1];
  275. /*<       t1=value(locp+3) >*/
  276.     t1 = blank_1.value[locp + 2];
  277. /*<       tau1=value(locp+4) >*/
  278.     tau1 = blank_1.value[locp + 3];
  279. /*<       t2=value(locp+5) >*/
  280.     t2 = blank_1.value[locp + 4];
  281. /*<       tau2=value(locp+6) >*/
  282.     tau2 = blank_1.value[locp + 5];
  283. /*<       time1=time >*/
  284.     time1 = status_1.time;
  285. /*<       if (time1.gt.t1) go to 310 >*/
  286.     if (time1 > t1) {
  287.         goto L310;
  288.     }
  289. /*<       value(locv+1)=v1 >*/
  290.     blank_1.value[locv] = v1;
  291. /*<       go to 490 >*/
  292.     goto L490;
  293. /*<   310 if (time1.gt.t2) go to 320 >*/
  294. L310:
  295.     if (time1 > t2) {
  296.         goto L320;
  297.     }
  298. /*<       value(locv+1)=v1+(v2-v1)*(1.0d0-dexp((t1-time1)/tau1)) >*/
  299.     blank_1.value[locv] = v1 + (v2 - v1) * (1. - exp((t1 - time1) / tau1))
  300.         ;
  301. /*<       go to 490 >*/
  302.     goto L490;
  303. /*<   320 value(locv+1)=v1+(v2-v1)*(1.0d0-dexp((t1-time1)/tau1)) >*/
  304. /*<      1   +(v1-v2)*(1.0d0-dexp((t2-time1)/tau2)) >*/
  305. L320:
  306.     blank_1.value[locv] = v1 + (v2 - v1) * (1. - exp((t1 - time1) / tau1))
  307.          + (v1 - v2) * (1. - exp((t2 - time1) / tau2));
  308. /*<       go to 490 >*/
  309.     goto L490;
  310.  
  311. /*  piecewise-linear source */
  312.  
  313. /*<   400 t1=value(locp+1) >*/
  314. L400:
  315.     t1 = blank_1.value[locp];
  316. /*<       v1=value(locp+2) >*/
  317.     v1 = blank_1.value[locp + 1];
  318. /*<       t2=value(locp+3) >*/
  319.     t2 = blank_1.value[locp + 2];
  320. /*<       v2=value(locp+4) >*/
  321.     v2 = blank_1.value[locp + 3];
  322. /*<       iknt=4 >*/
  323.     iknt = 4;
  324. /*<   410 if (time.le.t2) go to 420 >*/
  325. L410:
  326.     if (status_1.time <= t2) {
  327.         goto L420;
  328.     }
  329. /*<       t1=t2 >*/
  330.     t1 = t2;
  331. /*<       v1=v2 >*/
  332.     v1 = v2;
  333. /*<       t2=value(locp+iknt+1) >*/
  334.     t2 = blank_1.value[locp + iknt];
  335. /*<       v2=value(locp+iknt+2) >*/
  336.     v2 = blank_1.value[locp + iknt + 1];
  337. /*<       iknt=iknt+2 >*/
  338.     iknt += 2;
  339. /*<       go to 410 >*/
  340.     goto L410;
  341. /*<   420 value(locv+1)=v1+((time-t1)/(t2-t1))*(v2-v1) >*/
  342. L420:
  343.     blank_1.value[locv] = v1 + (status_1.time - t1) / (t2 - t1) * (v2 - 
  344.         v1);
  345. /*<       go to 490 >*/
  346.     goto L490;
  347.  
  348. /*  single-frequency fm */
  349.  
  350. /*<   450 v1=value(locp+1) >*/
  351. L450:
  352.     v1 = blank_1.value[locp];
  353. /*<       v2=value(locp+2) >*/
  354.     v2 = blank_1.value[locp + 1];
  355. /*<       omegc=value(locp+3) >*/
  356.     omegc = blank_1.value[locp + 2];
  357. /*<       xmod=value(locp+4) >*/
  358.     xmod = blank_1.value[locp + 3];
  359. /*<       omegs=value(locp+5) >*/
  360.     omegs = blank_1.value[locp + 4];
  361. /*<       value(locv+1)=v1+v2*dsin(omegc*time+xmod*dsin(omegs*time)) >*/
  362.     blank_1.value[locv] = v1 + v2 * sin(omegc * status_1.time + xmod * 
  363.         sin(omegs * status_1.time));
  364. /*<   490 loc=nodplc(loc) >*/
  365. L490:
  366.     loc = nodplc[loc - 1];
  367. /*<       go to 10 >*/
  368.     goto L10;
  369. /*<   500 continue >*/
  370. L500:
  371.     ;}
  372.  
  373. /*  update transmission line sources */
  374.  
  375. /*<       if (jelcnt(17).eq.0) go to 1000 >*/
  376.     if (cirdat_1.jelcnt[16] == 0) {
  377.     goto L1000;
  378.     }
  379. /*<       if (mode.ne.2) go to 1000 >*/
  380.     if (status_1.mode != 2) {
  381.     goto L1000;
  382.     }
  383. /*<       call sizmem(ltd,ltdsiz) >*/
  384.     sizmem_(&tabinf_1.ltd, <dsiz);
  385. /*<       numtd=ltdsiz/ntlin >*/
  386.     numtd = ltdsiz / cirdat_1.ntlin;
  387. /*<       if (numtd.lt.3) go to 900 >*/
  388.     if (numtd < 3) {
  389.     goto L900;
  390.     }
  391. /*<       loc=locate(17) >*/
  392.     loc = cirdat_1.locate[16];
  393. /*<   610 if (loc.eq.0) go to 1000 >*/
  394. L610:
  395.     if (loc == 0) {
  396.     goto L1000;
  397.     }
  398. /*<       locv=nodplc(loc+1) >*/
  399.     locv = nodplc[loc];
  400. /*<       td=value(locv+2) >*/
  401.     td = blank_1.value[locv + 1];
  402. /*<       baktim=time-td >*/
  403.     baktim = status_1.time - td;
  404. /*<       if (baktim.lt.0.0d0) go to 640 >*/
  405.     if (baktim < 0.) {
  406.     goto L640;
  407.     }
  408. /*<       ltdptr=nodplc(loc+30) >*/
  409.     ltdptr = nodplc[loc + 29];
  410. /*<       icntr=2 >*/
  411.     icntr = 2;
  412. /*<       l1=ltd >*/
  413.     l1 = tabinf_1.ltd;
  414. /*<       l2=l1+ntlin >*/
  415.     l2 = l1 + cirdat_1.ntlin;
  416. /*<       l3=l2+ntlin >*/
  417.     l3 = l2 + cirdat_1.ntlin;
  418. /*<       t1=value(l1+1) >*/
  419.     t1 = blank_1.value[l1];
  420. /*<       t2=value(l2+1) >*/
  421.     t2 = blank_1.value[l2];
  422. /*<   620 t3=value(l3+1) >*/
  423. L620:
  424.     t3 = blank_1.value[l3];
  425. /*<       icntr=icntr+1 >*/
  426.     ++icntr;
  427. /*<       if (baktim.le.t3) go to 630 >*/
  428.     if (baktim <= t3) {
  429.     goto L630;
  430.     }
  431. /*<       if (icntr.eq.numtd) go to 900 >*/
  432.     if (icntr == numtd) {
  433.     goto L900;
  434.     }
  435. /*<       l1=l2 >*/
  436.     l1 = l2;
  437. /*<       l2=l3 >*/
  438.     l2 = l3;
  439. /*<       l3=l2+ntlin >*/
  440.     l3 = l2 + cirdat_1.ntlin;
  441. /*<       t1=t2 >*/
  442.     t1 = t2;
  443. /*<       t2=t3 >*/
  444.     t2 = t3;
  445. /*<       go to 620 >*/
  446.     goto L620;
  447. /*<   630 dt1t2=t1-t2 >*/
  448. L630:
  449.     dt1t2 = t1 - t2;
  450. /*<       dt1t3=t1-t3 >*/
  451.     dt1t3 = t1 - t3;
  452. /*<       dt2t3=t2-t3 >*/
  453.     dt2t3 = t2 - t3;
  454. /*<       tdnom1=1.0d0/(dt1t2*dt1t3) >*/
  455.     tdnom1 = 1. / (dt1t2 * dt1t3);
  456. /*<       tdnom2=-1.0d0/(dt1t2*dt2t3) >*/
  457.     tdnom2 = -1. / (dt1t2 * dt2t3);
  458. /*<       tdnom3=1.0d0/(dt2t3*dt1t3) >*/
  459.     tdnom3 = 1. / (dt2t3 * dt1t3);
  460. /*<       dtt1=baktim-t1 >*/
  461.     dtt1 = baktim - t1;
  462. /*<       dtt2=baktim-t2 >*/
  463.     dtt2 = baktim - t2;
  464. /*<       dtt3=baktim-t3 >*/
  465.     dtt3 = baktim - t3;
  466. /*<       tfact1=dtt2*dtt3*tdnom1 >*/
  467.     tfact1 = dtt2 * dtt3 * tdnom1;
  468. /*<       tfact2=dtt1*dtt3*tdnom2 >*/
  469.     tfact2 = dtt1 * dtt3 * tdnom2;
  470. /*<       tfact3=dtt1*dtt2*tdnom3 >*/
  471.     tfact3 = dtt1 * dtt2 * tdnom3;
  472. /*<       value(locv+3)=value(l1+ltdptr+0)*tfact1+value(l2+ltdptr+0)*tfact2 >*/
  473. /*<      1   +value(l3+ltdptr+0)*tfact3 >*/
  474.     blank_1.value[locv + 2] = blank_1.value[l1 + ltdptr - 1] * tfact1 + 
  475.         blank_1.value[l2 + ltdptr - 1] * tfact2 + blank_1.value[l3 + 
  476.         ltdptr - 1] * tfact3;
  477. /*<       value(locv+4)=value(l1+ltdptr+1)*tfact1+value(l2+ltdptr+1)*tfact2 >*/
  478. /*<      1   +value(l3+ltdptr+1)*tfact3 >*/
  479.     blank_1.value[locv + 3] = blank_1.value[l1 + ltdptr] * tfact1 + 
  480.         blank_1.value[l2 + ltdptr] * tfact2 + blank_1.value[l3 + ltdptr] *
  481.          tfact3;
  482. /*<   640 loc=nodplc(loc) >*/
  483. L640:
  484.     loc = nodplc[loc - 1];
  485. /*<       go to 610 >*/
  486.     goto L610;
  487.  
  488. /*  internal logic error:  less than 3 entries in ltd */
  489.  
  490. /*<   900 nogo=1 >*/
  491. L900:
  492.     flags_1.nogo = 1;
  493. /*<       write (iofile,901) numtd,icntr >*/
  494.     io__45.ciunit = status_1.iofile;
  495.     s_wsfe(&io__45);
  496.     do_fio(&c__1, (char *)&numtd, (ftnlen)sizeof(integer));
  497.     do_fio(&c__1, (char *)&icntr, (ftnlen)sizeof(integer));
  498.     e_wsfe();
  499. /*<   901 format('0*abort*:  internal spice error:  sorupd:  ',2i5/) >*/
  500.  
  501. /*  finished */
  502.  
  503. /*<  1000 return >*/
  504. L1000:
  505.     return 0;
  506. /*<       end >*/
  507. } /* sorupd_ */
  508.  
  509. #undef cvalue
  510. #undef nodplc
  511.  
  512.  
  513.